// @class TileLayer

L.TileLayer.mergeOptions({
  // @option keepBuffer
  // The amount of tiles outside the visible map area to be kept in the stitched
  // `TileLayer`.

  // @option dumpToCanvas: Boolean = true
  // Whether to dump loaded tiles to a `<canvas>` to prevent some rendering
  // artifacts. (Disabled by default in IE)
  dumpToCanvas: L.Browser.canvas && !L.Browser.ie,
});

L.TileLayer.include({
  _onUpdateLevel: function (z, zoom) {
    if (this.options.dumpToCanvas) {
      this._levels[z].canvas.style.zIndex =
        this.options.maxZoom - Math.abs(zoom - z);
    }
  },

  _onRemoveLevel: function (z) {
    if (this.options.dumpToCanvas) {
      L.DomUtil.remove(this._levels[z].canvas);
    }
  },

  _onCreateLevel: function (level) {
    if (this.options.dumpToCanvas) {
      level.canvas = L.DomUtil.create(
        "canvas",
        "leaflet-tile-container leaflet-zoom-animated",
        this._container
      );
      level.ctx = level.canvas.getContext("2d");
      this._resetCanvasSize(level);
    }
  },

  _removeTile: function (key) {
    if (this.options.dumpToCanvas) {
      var tile = this._tiles[key];
      var level = this._levels[tile.coords.z];
      var tileSize = this.getTileSize();

      if (level) {
        // Where in the canvas should this tile go?
        var offset = L.point(tile.coords.x, tile.coords.y)
          .subtract(level.canvasRange.min)
          .scaleBy(this.getTileSize());

        level.ctx.clearRect(offset.x, offset.y, tileSize.x, tileSize.y);
      }
    }

    L.GridLayer.prototype._removeTile.call(this, key);
  },

  _resetCanvasSize: function (level) {
    var buff = this.options.keepBuffer,
      pixelBounds = this._getTiledPixelBounds(this._map.getCenter()),
      tileRange = this._pxBoundsToTileRange(pixelBounds),
      tileSize = this.getTileSize();

    tileRange.min = tileRange.min.subtract([buff, buff]); // This adds the no-prune buffer
    tileRange.max = tileRange.max.add([buff + 1, buff + 1]);

    var pixelRange = L.bounds(
      tileRange.min.scaleBy(tileSize),
      tileRange.max.add([1, 1]).scaleBy(tileSize) // This prevents an off-by-one when checking if tiles are inside
    ),
      mustRepositionCanvas = false,
      neededSize = pixelRange.max.subtract(pixelRange.min);

    // Resize the canvas, if needed, and only to make it bigger.
    if (
      neededSize.x > level.canvas.width ||
      neededSize.y > level.canvas.height
    ) {
      // Resizing canvases erases the currently drawn content, I'm afraid.
      // To keep it, dump the pixels to another canvas, then display it on
      // top. This could be done with getImageData/putImageData, but that
      // would break for tainted canvases (in non-CORS tilesets)
      var oldSize = { x: level.canvas.width, y: level.canvas.height };
      // console.info('Resizing canvas from ', oldSize, 'to ', neededSize);

      var tmpCanvas = L.DomUtil.create("canvas");
      tmpCanvas.style.width = (tmpCanvas.width = oldSize.x) + "px";
      tmpCanvas.style.height = (tmpCanvas.height = oldSize.y) + "px";
      tmpCanvas.getContext("2d").drawImage(level.canvas, 0, 0);
      // var data = level.ctx.getImageData(0, 0, oldSize.x, oldSize.y);

      level.canvas.style.width = (level.canvas.width = neededSize.x) + "px";
      level.canvas.style.height = (level.canvas.height = neededSize.y) + "px";
      level.ctx.drawImage(tmpCanvas, 0, 0);
      // level.ctx.putImageData(data, 0, 0, 0, 0, oldSize.x, oldSize.y);
    }

    // Translate the canvas contents if it's moved around
    if (level.canvasRange) {
      var offset = level.canvasRange.min
        .subtract(tileRange.min)
        .scaleBy(this.getTileSize());

      // 			console.info('Offsetting by ', offset);

      if (!L.Browser.safari) {
        // By default, canvases copy things "on top of" existing pixels, but we want
        // this to *replace* the existing pixels when doing a drawImage() call.
        // This will also clear the sides, so no clearRect() calls are needed to make room
        // for the new tiles.
        level.ctx.globalCompositeOperation = "copy";
        level.ctx.drawImage(level.canvas, offset.x, offset.y);
        level.ctx.globalCompositeOperation = "source-over";
      } else {
        // Safari clears the canvas when copying from itself :-(
        if (!this._tmpCanvas) {
          var t = (this._tmpCanvas = L.DomUtil.create("canvas"));
          t.width = level.canvas.width;
          t.height = level.canvas.height;
          this._tmpContext = t.getContext("2d");
        }
        this._tmpContext.clearRect(
          0,
          0,
          level.canvas.width,
          level.canvas.height
        );
        this._tmpContext.drawImage(level.canvas, 0, 0);
        level.ctx.clearRect(0, 0, level.canvas.width, level.canvas.height);
        level.ctx.drawImage(this._tmpCanvas, offset.x, offset.y);
      }

      mustRepositionCanvas = true; // Wait until new props are set
    }

    level.canvasRange = tileRange;
    level.canvasPxRange = pixelRange;
    level.canvasOrigin = pixelRange.min;

    // console.log('Canvas tile range: ', level, tileRange.min, tileRange.max );
    // console.log('Canvas pixel range: ', pixelRange.min, pixelRange.max );
    // console.log('Level origin: ', level.origin );

    if (mustRepositionCanvas) {
      this._setCanvasZoomTransform(
        level,
        this._map.getCenter(),
        this._map.getZoom()
      );
    }
  },

  /// set transform/position of canvas, in addition to the transform/position of the individual tile container
  _setZoomTransform: function (level, center, zoom) {
    L.GridLayer.prototype._setZoomTransform.call(this, level, center, zoom);
    if (this.options.dumpToCanvas) {
      this._setCanvasZoomTransform(level, center, zoom);
    }
  },

  // This will get called twice:
  // * From _setZoomTransform
  // * When the canvas has shifted due to a new tile being loaded
  _setCanvasZoomTransform: function (level, center, zoom) {
    // console.log('_setCanvasZoomTransform', level, center, zoom);
    if (!level.canvasOrigin) {
      return;
    }
    var scale = this._map.getZoomScale(zoom, level.zoom),
      translate = level.canvasOrigin
        .multiplyBy(scale)
        .subtract(this._map._getNewPixelOrigin(center, zoom))
        .round();

    if (L.Browser.any3d) {
      L.DomUtil.setTransform(level.canvas, translate, scale);
    } else {
      L.DomUtil.setPosition(level.canvas, translate);
    }
  },

  _onOpaqueTile: function (tile) {
    if (!this.options.dumpToCanvas) {
      return;
    }

    // Guard against an NS_ERROR_NOT_AVAILABLE (or similar) exception
    // when a non-image-tile has been loaded (e.g. a WMS error).
    // Checking for tile.el.complete is not enough, as it has been
    // already marked as loaded and ready somehow.
    try {
      this.dumpPixels(tile.coords, tile.el);
    } catch (ex) {
      return this.fire("tileerror", {
        error: "Could not copy tile pixels: " + ex,
        tile: tile,
        coods: tile.coords,
      });
    }

    // If dumping the pixels was successful, then hide the tile.
    // Do not remove the tile itself, as it is needed to check if the whole
    // level (and its canvas) should be removed (via level.el.children.length)
    tile.el.style.display = "none";
  },

  // @section Extension methods
  // @uninheritable

  // @method dumpPixels(coords: Object, imageSource: CanvasImageSource): this
  // Dumps pixels from the given `CanvasImageSource` into the layer, into
  // the space for the tile represented by the `coords` tile coordinates (an object
  // like `{x: Number, y: Number, z: Number}`; the image source must have the
  // same size as the `tileSize` option for the layer. Has no effect if `dumpToCanvas`
  // is `false`.
  dumpPixels: function (coords, imageSource) {
    var level = this._levels[coords.z],
      tileSize = this.getTileSize();

    if (!level.canvasRange || !this.options.dumpToCanvas) {
      return;
    }

    // Check if the tile is inside the currently visible map bounds
    // There is a possible race condition when tiles are loaded after they
    // have been panned outside of the map.
    if (!level.canvasRange.contains(coords)) {
      this._resetCanvasSize(level);
    }

    // Where in the canvas should this tile go?
    var offset = L.point(coords.x, coords.y)
      .subtract(level.canvasRange.min)
      .scaleBy(this.getTileSize());

    level.ctx.drawImage(imageSource, offset.x, offset.y, tileSize.x, tileSize.y);

    // TODO: Clear the pixels of other levels' canvases where they overlap
    // this newly dumped tile.
    return this;
  },
});